home *** CD-ROM | disk | FTP | other *** search
/ CICA 1995 August / CICA - The Ultimate Collection of Shareware for Windows (Disc 2) (August 1995).iso / disc2 / demo / pwrtcp11.exe / TNTC.C_ / TNTC.bin
Text File  |  1994-11-18  |  38KB  |  1,266 lines
  1. //---------------------------------------------------------------------------
  2. //
  3. //  Module: tty.c
  4. //
  5. //  Purpose:
  6. //     The sample application demonstrates the usage of the COMM
  7. //     API.  It implements the new COMM API of Windows 3.1.
  8. //
  9. //     NOTE:  no escape sequences are translated, only
  10. //            the necessary control codes (LF, CR, BS, etc.)
  11. //
  12. //  Description of functions:
  13. //     Descriptions are contained in the function headers.
  14. //
  15. //---------------------------------------------------------------------------
  16. //
  17. //  Written by Microsoft Product Support Services, Windows Developer Support.
  18. //  Copyright (c) 1991 Microsoft Corporation.  All Rights Reserved.
  19. //
  20. //---------------------------------------------------------------------------
  21.  
  22. //************************************************************************
  23. //
  24. //  Module: tntc.c
  25. //
  26. //  Purpose:
  27. //     The sample application demonstrates the usage of the PowerTCP
  28. //     API.  It uses the new PowerTCP DLL interface. Compiled under Windows 3.1
  29. //     and Windows NT 3.5 Beta
  30. //
  31. //     NOTE: This code was derived from Microsoft's tty.c
  32. //             
  33. //************************************************************************
  34. //
  35. //  Written by Dart Communication Application Programming Group.
  36. //  Copyright (c) 1994 Dart Communications.  All Rights Reserved.
  37. //
  38. //************************************************************************
  39.  
  40. #define STRICT       // be bold!
  41. #pragma warning (disable:4100 4355 4699)
  42.  
  43. #include <windows.h>
  44. #include <commdlg.h>
  45. #include <string.h>
  46.  
  47. #include "version.h"
  48. #include "tntc.hh"
  49. #include "..\..\include\powertcp.h"
  50. #include "tntsamp.h"
  51.  
  52. HPOWERTCP     hPowerTcp = NULL; // session identifier
  53. char           szHost[20]="" ;
  54. char              szPort[5]="23" ;          
  55. WORD            Port;
  56. BOOL            TransOk;
  57. HINSTANCE    hInstance;
  58. PTTYINFO TTYInfo=NULL; 
  59. HICON            hIcon=NULL;
  60.  
  61. // FARPROC's for MakeProcInstance
  62. FARPROC MyConnectEvent, MyRecvEvent, MySendEvent, MyExceptionEvent, MyCmdEvent;
  63.  
  64.  
  65. //---------------------------------------------------------------------------
  66. //  int PASCAL WinMain( HANDLE hInstance, HANDLE hPrevInstance,
  67. //                      LPSTR lpszCmdLine, int nCmdShow )
  68. //
  69. //  Description:
  70. //     This is the main window loop!
  71. //
  72. //  Parameters:
  73. //     As documented for all WinMain() functions.
  74. //
  75. //---------------------------------------------------------------------------
  76.  
  77. int PASCAL WinMain( HINSTANCE hNewInstance, HINSTANCE hPrevInstance,
  78.                     LPSTR lpszCmdLine, int nCmdShow )
  79. {
  80.    HWND  hTTYWnd ;
  81.    MSG   msg ;
  82.  
  83.    hInstance=hNewInstance;
  84.  
  85.    if (!hPrevInstance)
  86.       if (!InitApplication( hInstance ))
  87.          return ( FALSE ) ;
  88.  
  89.    if (NULL == (hTTYWnd = InitInstance( hInstance, nCmdShow )))
  90.       return ( FALSE ) ;
  91.  
  92.    while (GetMessage( &msg, NULL, 0, 0 ))
  93.    {
  94.       if (!TranslateAccelerator( hTTYWnd, ghAccel, &msg ))
  95.       {
  96.          TranslateMessage( &msg ) ;
  97.          DispatchMessage( &msg ) ;
  98.       }
  99.    }
  100.    
  101.    // Free callbacks
  102.    FreeProcInstance(MyConnectEvent);
  103.    FreeProcInstance(MyCmdEvent);
  104.    FreeProcInstance(MyRecvEvent);
  105.    FreeProcInstance(MySendEvent);
  106.    FreeProcInstance(MyExceptionEvent);
  107.    
  108.    if (UnregisterClass(gszTTYClass,hInstance) && hIcon)
  109.        DestroyIcon(hIcon);
  110.    return ( (int) msg.wParam ) ;
  111.  
  112. } // end of WinMain()
  113.  
  114. //---------------------------------------------------------------------------
  115. //  BOOL NEAR InitApplication( HANDLE hInstance )
  116. //
  117. //  Description:
  118. //     First time initialization stuff.  This registers information
  119. //     such as window classes.
  120. //
  121. //  Parameters:
  122. //     HANDLE hInstance
  123. //        Handle to this instance of the application.
  124. //
  125. //---------------------------------------------------------------------------
  126.  
  127. BOOL NEAR InitApplication( HINSTANCE hInstance )
  128. {
  129.    WNDCLASS  wndclass ;
  130.  
  131.    // register tty window class
  132.  
  133.    wndclass.style =         0 ;
  134.    wndclass.lpfnWndProc =   TTYWndProc ;
  135.    wndclass.cbClsExtra =    0 ;
  136.    wndclass.cbWndExtra =    0;
  137.    wndclass.hInstance =     hInstance ;
  138.    hIcon=wndclass.hIcon =         LoadIcon( hInstance, "PowerTNT" );
  139.    wndclass.hCursor =       LoadCursor( NULL, IDC_ARROW ) ;
  140.    wndclass.hbrBackground = (HBRUSH) (COLOR_WINDOW + 1) ;
  141.    wndclass.lpszMenuName =  MAKEINTRESOURCE( TTYMENU ) ;
  142.    wndclass.lpszClassName = gszTTYClass ;
  143.  
  144.    return( RegisterClass( &wndclass ) ) ;
  145.  
  146. } // end of InitApplication()
  147.  
  148. //---------------------------------------------------------------------------
  149. //  LRESULT FAR PASCAL __export TTYWndProc( HWND hWnd, UINT uMsg,
  150. //                                 WPARAM wParam, LPARAM lParam )
  151. //
  152. //  Description:
  153. //     This is the TTY Window Proc.  This handles ALL messages
  154. //     to the tty window.
  155. //
  156. //  Parameters:
  157. //     As documented for Window procedures.
  158. //
  159. //---------------------------------------------------------------------------
  160.  
  161. LRESULT CALLBACK TTYWndProc( HWND hWnd, UINT uMsg,
  162.                                WPARAM wParam, LPARAM lParam )
  163. {
  164.    switch (uMsg)
  165.    {
  166.       case WM_CREATE:
  167.          return ( CreateTTYInfo( hWnd ) ) ;
  168.  
  169.       case WM_COMMAND:
  170.       {
  171.          switch ((WORD) wParam)
  172.          {
  173.             case IDM_CONNECT:
  174.                if (!OpenConnection( hWnd ))
  175.                   MessageBox( hWnd, "Connection failed.", gszAppName,
  176.                               MB_ICONEXCLAMATION ) ;
  177.                break ;
  178.  
  179.             case IDM_DISCONNECT:
  180.                CloseConnection( hWnd ) ;
  181.                break ;
  182.  
  183.             case IDM_ABOUT:
  184.                GoModalDialogBoxParam ( hInstance,
  185.                                        MAKEINTRESOURCE( ABOUTDLGBOX ),
  186.                                        hWnd,
  187.                                        AboutDlgProc, 0l ) ;
  188.                break;
  189.  
  190.             case IDM_EXIT:
  191.                PostMessage( hWnd, WM_CLOSE, 0, 0L ) ;
  192.                break ;
  193.          }
  194.       }
  195.       break ;
  196.  
  197.       case WM_PAINT:
  198.          PaintTTY( hWnd ) ;
  199.          break ;
  200.  
  201.       case WM_SIZE:
  202.          SizeTTY( hWnd, HIWORD( lParam ), LOWORD( lParam ) ) ;
  203.          break ;
  204.  
  205.       case WM_HSCROLL:
  206.          ScrollTTYHorz( hWnd, (WORD) wParam, LOWORD( lParam ) ) ;
  207.          break ;
  208.  
  209.       case WM_VSCROLL:
  210.          ScrollTTYVert( hWnd, (WORD) wParam, LOWORD( lParam ) ) ;
  211.          break ;
  212.  
  213.       case WM_CHAR:
  214.          ProcessTTYCharacter( hWnd, LOBYTE( wParam ) ) ;
  215.          break ;
  216.  
  217.       case WM_SETFOCUS:
  218.          SetTTYFocus( hWnd ) ;
  219.          break ;
  220.  
  221.       case WM_KILLFOCUS:
  222.          KillTTYFocus( hWnd ) ;
  223.          break ;
  224.  
  225.       case WM_DESTROY:
  226.          DestroyTTYInfo( hWnd ) ;
  227.          PostQuitMessage( 0 ) ;
  228.          break ;
  229.  
  230.       case WM_CLOSE:
  231.           if (hPowerTcp)
  232.               CloseTelnet(hPowerTcp,TRUE); // abort
  233.          GoModalDialogBoxParam ( hInstance,
  234.                                        MAKEINTRESOURCE( ABOUTDLGBOX ),
  235.                                        hWnd,
  236.                                        AboutDlgProc, 0l ) ;
  237.          // fall through
  238.  
  239.       default:
  240.          return( DefWindowProc( hWnd, uMsg, wParam, lParam ) ) ;
  241.    }
  242.    return 0L ;
  243.  
  244. } // end of TTYWndProc()
  245.  
  246. //---------------------------------------------------------------------------
  247. //  LRESULT NEAR CreateTTYInfo( HWND hWnd )
  248. //
  249. //  Description:
  250. //     Creates the tty information structure and sets
  251. //     menu option availability.  Returns -1 if unsuccessful.
  252. //
  253. //  Parameters:
  254. //     HWND  hWnd
  255. //        Handle to main window.
  256. //
  257. //---------------------------------------------------------------------------
  258.  
  259. LRESULT NEAR CreateTTYInfo( HWND hWnd )
  260. {
  261.    HMENU       hMenu ;
  262.  
  263.    if (NULL == (TTYInfo =
  264.                    (PTTYINFO) LocalAlloc( LPTR, sizeof( TTYINFO ) )))
  265.       return ( (LRESULT) -1 ) ;
  266.  
  267.    // initialize TTY info structure
  268.  
  269.    COMDEV( TTYInfo )        = 0 ;
  270.    CONNECTED( TTYInfo )     = FALSE ;
  271.    CURSORSTATE( TTYInfo )   = CS_HIDE ;
  272.    LOCALECHO( TTYInfo )     = FALSE ;
  273.    AUTOWRAP( TTYInfo )      = TRUE ;
  274.  
  275.    // clear screen space
  276.    memset( SCREEN( TTYInfo ), ' ', MAXROWS * MAXCOLS ) ;
  277.  
  278.    // setup default font information
  279.  
  280.    LFTTYFONT( TTYInfo ).lfHeight =         12 ;
  281.    LFTTYFONT( TTYInfo ).lfWidth =          0 ;
  282.    LFTTYFONT( TTYInfo ).lfEscapement =     0 ;
  283.    LFTTYFONT( TTYInfo ).lfOrientation =    0 ;
  284.    LFTTYFONT( TTYInfo ).lfWeight =         0 ;
  285.    LFTTYFONT( TTYInfo ).lfItalic =         0 ;
  286.    LFTTYFONT( TTYInfo ).lfUnderline =      0 ;
  287.    LFTTYFONT( TTYInfo ).lfStrikeOut =      0 ;
  288.    LFTTYFONT( TTYInfo ).lfCharSet =        OEM_CHARSET ;
  289.    LFTTYFONT( TTYInfo ).lfOutPrecision =   OUT_DEFAULT_PRECIS ;
  290.    LFTTYFONT( TTYInfo ).lfClipPrecision =  CLIP_DEFAULT_PRECIS ;
  291.    LFTTYFONT( TTYInfo ).lfQuality =        DEFAULT_QUALITY ;
  292.    LFTTYFONT( TTYInfo ).lfPitchAndFamily = FIXED_PITCH | FF_MODERN ;
  293.    LFTTYFONT( TTYInfo ).lfFaceName[0] =    0 ;
  294.  
  295.    // reset the character information, etc.
  296.  
  297.    ResetTTYScreen( hWnd ) ;
  298.  
  299.    hMenu = GetMenu( hWnd ) ;
  300.    EnableMenuItem( hMenu, IDM_DISCONNECT,
  301.                    MF_GRAYED | MF_DISABLED | MF_BYCOMMAND ) ;
  302.    EnableMenuItem( hMenu, IDM_CONNECT, MF_ENABLED | MF_BYCOMMAND ) ;
  303.  
  304.    return ( (LRESULT) TRUE ) ;
  305.  
  306. } // end of CreateTTYInfo()
  307.  
  308. //---------------------------------------------------------------------------
  309. //  BOOL NEAR DestroyTTYInfo( HWND hWnd )
  310. //
  311. //  Description:
  312. //     Destroys block associated with TTY window handle.
  313. //
  314. //  Parameters:
  315. //     HWND hWnd
  316. //        handle to TTY window
  317. //
  318. //---------------------------------------------------------------------------
  319.  
  320. BOOL NEAR DestroyTTYInfo( HWND hWnd )
  321. {
  322.  
  323.    if (!TTYInfo)
  324.       return ( FALSE ) ;
  325.  
  326.    // force connection closed (if not already closed)
  327.  
  328.    if (CONNECTED( TTYInfo ))
  329.       CloseConnection( hWnd ) ;
  330.  
  331.    DeleteObject( HTTYFONT( TTYInfo ) ) ;
  332.  
  333.    LocalFree( TTYInfo ) ;
  334.    return ( TRUE ) ;
  335.  
  336. } // end of DestroyTTYInfo()
  337.  
  338. //---------------------------------------------------------------------------
  339. //  BOOL NEAR ResetTTYScreen( HWND hWnd, PTTYINFO TTYInfo )
  340. //
  341. //  Description:
  342. //     Resets the TTY character information and causes the
  343. //     screen to resize to update the scroll information.
  344. //
  345. //  Parameters:
  346. //     PTTYINFO  TTYInfo
  347. //        pointer to TTY info structure
  348. //
  349. //---------------------------------------------------------------------------
  350.  
  351. BOOL NEAR ResetTTYScreen( HWND hWnd)
  352. {
  353.    HDC         hDC ;
  354.    TEXTMETRIC  tm ;
  355.    RECT        rcWindow ;
  356.  
  357.    if (NULL == TTYInfo)
  358.       return ( FALSE ) ;
  359.  
  360.    if (NULL != HTTYFONT( TTYInfo ))
  361.       DeleteObject( HTTYFONT( TTYInfo ) ) ;
  362.  
  363.    HTTYFONT( TTYInfo ) = CreateFontIndirect( &LFTTYFONT( TTYInfo ) ) ;
  364.  
  365.    hDC = GetDC( hWnd ) ;
  366.    SelectObject( hDC, HTTYFONT( TTYInfo ) ) ;
  367.    GetTextMetrics( hDC, &tm ) ;
  368.    ReleaseDC( hWnd, hDC ) ;
  369.  
  370.    XCHAR( TTYInfo ) = tm.tmAveCharWidth  ;
  371.    YCHAR( TTYInfo ) = tm.tmHeight + tm.tmExternalLeading ;
  372.  
  373.    // a slimy hack to force the scroll position, region to
  374.    // be recalculated based on the new character sizes
  375.  
  376.    GetWindowRect( hWnd, &rcWindow ) ;
  377.    SendMessage( hWnd, WM_SIZE, SIZENORMAL,
  378.                 (LPARAM) MAKELONG( rcWindow.right - rcWindow.left,
  379.                                    rcWindow.bottom - rcWindow.top ) ) ;
  380.  
  381.    return ( TRUE ) ;
  382.  
  383. } // end of ResetTTYScreen()
  384.  
  385. //---------------------------------------------------------------------------
  386. //  BOOL NEAR PaintTTY( HWND hWnd )
  387. //
  388. //  Description:
  389. //     Paints the rectangle determined by the paint struct of
  390. //     the DC.
  391. //
  392. //  Parameters:
  393. //     HWND hWnd
  394. //        handle to TTY window (as always)
  395. //
  396. //---------------------------------------------------------------------------
  397.  
  398. BOOL NEAR PaintTTY( HWND hWnd )
  399. {
  400.    int          nRow, nCol, nEndRow, nEndCol, nCount, nHorzPos, nVertPos ;
  401.    HDC          hDC ;
  402.    HGDIOBJ      hOldFont ;
  403.    PAINTSTRUCT  ps ;
  404.    RECT         rect ;
  405.  
  406.    if (NULL == TTYInfo)
  407.       return ( FALSE ) ;
  408.  
  409.    hDC = BeginPaint( hWnd, &ps ) ;
  410.    hOldFont = SelectObject( hDC, HTTYFONT( TTYInfo ) ) ;
  411.    SetTextColor( hDC, FGCOLOR( TTYInfo ) ) ;
  412.    SetBkColor( hDC, GetSysColor( COLOR_WINDOW ) ) ;
  413.    rect = ps.rcPaint ;
  414.    nRow =
  415.       min( MAXROWS - 1,
  416.            max( 0, (rect.top + YOFFSET( TTYInfo )) / YCHAR( TTYInfo ) ) ) ;
  417.    nEndRow =
  418.       min( MAXROWS - 1,
  419.            ((rect.bottom + YOFFSET( TTYInfo ) - 1) / YCHAR( TTYInfo ) ) ) ;
  420.    nCol =
  421.       min( MAXCOLS - 1,
  422.            max( 0, (rect.left + XOFFSET( TTYInfo )) / XCHAR( TTYInfo ) ) ) ;
  423.    nEndCol =
  424.       min( MAXCOLS - 1,
  425.            ((rect.right + XOFFSET( TTYInfo ) - 1) / XCHAR( TTYInfo ) ) ) ;
  426.    nCount = nEndCol - nCol + 1 ;
  427.    for (; nRow <= nEndRow; nRow++)
  428.    {
  429.       nVertPos = (nRow * YCHAR( TTYInfo )) - YOFFSET( TTYInfo ) ;
  430.       nHorzPos = (nCol * XCHAR( TTYInfo )) - XOFFSET( TTYInfo ) ;
  431.       rect.top = nVertPos ;
  432.       rect.bottom = nVertPos + YCHAR( TTYInfo ) ;
  433.       rect.left = nHorzPos ;
  434.       rect.right = nHorzPos + XCHAR( TTYInfo ) * nCount ;
  435.       SetBkMode( hDC, OPAQUE ) ;
  436.       ExtTextOut( hDC, nHorzPos, nVertPos, ETO_OPAQUE | ETO_CLIPPED, &rect,
  437.                   (LPSTR)( SCREEN( TTYInfo ) + nRow * MAXCOLS + nCol ),
  438.                   nCount, NULL ) ;
  439.    }
  440.    SelectObject( hDC, hOldFont ) ;
  441.    EndPaint( hWnd, &ps ) ;
  442.    MoveTTYCursor( hWnd ) ;
  443.    return ( TRUE ) ;
  444.  
  445. } // end of PaintTTY()
  446.  
  447. //---------------------------------------------------------------------------
  448. //  BOOL NEAR SizeTTY( HWND hWnd, WORD wVertSize, WORD wHorzSize )
  449. //
  450. //  Description:
  451. //     Sizes TTY and sets up scrolling regions.
  452. //
  453. //  Parameters:
  454. //     HWND hWnd
  455. //        handle to TTY window
  456. //
  457. //     WORD wVertSize
  458. //        new vertical size
  459. //
  460. //     WORD wHorzSize
  461. //        new horizontal size
  462. //
  463. //---------------------------------------------------------------------------
  464.  
  465. BOOL NEAR SizeTTY( HWND hWnd, WORD wVertSize, WORD wHorzSize )
  466. {
  467.    int        nScrollAmt ;
  468.  
  469.    if (NULL == TTYInfo)
  470.       return ( FALSE ) ;
  471.  
  472.    YSIZE( TTYInfo ) = (int) wVertSize ;
  473.    YSCROLL( TTYInfo ) = max( 0, (MAXROWS * YCHAR( TTYInfo )) -
  474.                                YSIZE( TTYInfo ) ) ;
  475.    nScrollAmt = min( YSCROLL( TTYInfo ), YOFFSET( TTYInfo ) ) -
  476.                      YOFFSET( TTYInfo ) ;
  477.    ScrollWindow( hWnd, 0, -nScrollAmt, NULL, NULL ) ;
  478.  
  479.    YOFFSET( TTYInfo ) = YOFFSET( TTYInfo ) + nScrollAmt ;
  480.    SetScrollPos( hWnd, SB_VERT, YOFFSET( TTYInfo ), FALSE ) ;
  481.    SetScrollRange( hWnd, SB_VERT, 0, YSCROLL( TTYInfo ), TRUE ) ;
  482.  
  483.    XSIZE( TTYInfo ) = (int) wHorzSize ;
  484.    XSCROLL( TTYInfo ) = max( 0, (MAXCOLS * XCHAR( TTYInfo )) -
  485.                                 XSIZE( TTYInfo ) ) ;
  486.    nScrollAmt = min( XSCROLL( TTYInfo ), XOFFSET( TTYInfo )) -
  487.                      XOFFSET( TTYInfo ) ;
  488.    ScrollWindow( hWnd, 0, -nScrollAmt, NULL, NULL ) ;
  489.    XOFFSET( TTYInfo ) = XOFFSET( TTYInfo ) + nScrollAmt ;
  490.    SetScrollPos( hWnd, SB_HORZ, XOFFSET( TTYInfo ), FALSE ) ;
  491.    SetScrollRange( hWnd, SB_HORZ, 0, XSCROLL( TTYInfo ), TRUE ) ;
  492.  
  493.    InvalidateRect( hWnd, NULL, TRUE ) ;
  494.  
  495.    return ( TRUE ) ;
  496.  
  497. } // end of SizeTTY()
  498.  
  499. //---------------------------------------------------------------------------
  500. //  BOOL NEAR ScrollTTYVert( HWND hWnd, WORD wScrollCmd, WORD wScrollPos )
  501. //
  502. //  Description:
  503. //     Scrolls TTY window vertically.
  504. //
  505. //  Parameters:
  506. //     HWND hWnd
  507. //        handle to TTY window
  508. //
  509. //     WORD wScrollCmd
  510. //        type of scrolling we're doing
  511. //
  512. //     WORD wScrollPos
  513. //        scroll position
  514. //
  515. //---------------------------------------------------------------------------
  516.  
  517. BOOL NEAR ScrollTTYVert( HWND hWnd, WORD wScrollCmd, WORD wScrollPos )
  518. {
  519.    int        nScrollAmt ;
  520.  
  521.    if (NULL == TTYInfo)
  522.       return ( FALSE ) ;
  523.  
  524.    switch (wScrollCmd)
  525.    {
  526.       case SB_TOP:
  527.          nScrollAmt = -YOFFSET( TTYInfo ) ;
  528.          break ;
  529.  
  530.       case SB_BOTTOM:
  531.          nScrollAmt = YSCROLL( TTYInfo ) - YOFFSET( TTYInfo ) ;
  532.          break ;
  533.  
  534.       case SB_PAGEUP:
  535.          nScrollAmt = -YSIZE( TTYInfo ) ;
  536.          break ;
  537.  
  538.       case SB_PAGEDOWN:
  539.          nScrollAmt = YSIZE( TTYInfo ) ;
  540.          break ;
  541.  
  542.       case SB_LINEUP:
  543.          nScrollAmt = -YCHAR( TTYInfo ) ;
  544.          break ;
  545.  
  546.       case SB_LINEDOWN:
  547.          nScrollAmt = YCHAR( TTYInfo ) ;
  548.          break ;
  549.  
  550.       case SB_THUMBPOSITION:
  551.          nScrollAmt = wScrollPos - YOFFSET( TTYInfo ) ;
  552.          break ;
  553.  
  554.       default:
  555.          return ( FALSE ) ;
  556.    }
  557.    if ((YOFFSET( TTYInfo ) + nScrollAmt) > YSCROLL( TTYInfo ))
  558.       nScrollAmt = YSCROLL( TTYInfo ) - YOFFSET( TTYInfo ) ;
  559.    if ((YOFFSET( TTYInfo ) + nScrollAmt) < 0)
  560.       nScrollAmt = -YOFFSET( TTYInfo ) ;
  561.    ScrollWindow( hWnd, 0, -nScrollAmt, NULL, NULL ) ;
  562.    YOFFSET( TTYInfo ) = YOFFSET( TTYInfo ) + nScrollAmt ;
  563.    SetScrollPos( hWnd, SB_VERT, YOFFSET( TTYInfo ), TRUE ) ;
  564.  
  565.    return ( TRUE ) ;
  566.  
  567. } // end of ScrollTTYVert()
  568.  
  569. //---------------------------------------------------------------------------
  570. //  BOOL NEAR ScrollTTYHorz( HWND hWnd, WORD wScrollCmd, WORD wScrollPos )
  571. //
  572. //  Description:
  573. //     Scrolls TTY window horizontally.
  574. //
  575. //  Parameters:
  576. //     HWND hWnd
  577. //        handle to TTY window
  578. //
  579. //     WORD wScrollCmd
  580. //        type of scrolling we're doing
  581. //
  582. //     WORD wScrollPos
  583. //        scroll position
  584. //
  585. //---------------------------------------------------------------------------
  586.  
  587. BOOL NEAR ScrollTTYHorz( HWND hWnd, WORD wScrollCmd, WORD wScrollPos )
  588. {
  589.    int        nScrollAmt ;
  590.  
  591.    if (NULL == TTYInfo)
  592.       return ( FALSE ) ;
  593.  
  594.    switch (wScrollCmd)
  595.    {
  596.       case SB_TOP:
  597.          nScrollAmt = -XOFFSET( TTYInfo ) ;
  598.          break ;
  599.  
  600.       case SB_BOTTOM:
  601.          nScrollAmt = XSCROLL( TTYInfo ) - XOFFSET( TTYInfo ) ;
  602.          break ;
  603.  
  604.       case SB_PAGEUP:
  605.          nScrollAmt = -XSIZE( TTYInfo ) ;
  606.          break ;
  607.  
  608.       case SB_PAGEDOWN:
  609.          nScrollAmt = XSIZE( TTYInfo ) ;
  610.          break ;
  611.  
  612.       case SB_LINEUP:
  613.          nScrollAmt = -XCHAR( TTYInfo ) ;
  614.          break ;
  615.  
  616.       case SB_LINEDOWN:
  617.          nScrollAmt = XCHAR( TTYInfo ) ;
  618.          break ;
  619.  
  620.       case SB_THUMBPOSITION:
  621.          nScrollAmt = wScrollPos - XOFFSET( TTYInfo ) ;
  622.          break ;
  623.  
  624.       default:
  625.          return ( FALSE ) ;
  626.    }
  627.    if ((XOFFSET( TTYInfo ) + nScrollAmt) > XSCROLL( TTYInfo ))
  628.       nScrollAmt = XSCROLL( TTYInfo ) - XOFFSET( TTYInfo ) ;
  629.    if ((XOFFSET( TTYInfo ) + nScrollAmt) < 0)
  630.       nScrollAmt = -XOFFSET( TTYInfo ) ;
  631.    ScrollWindow( hWnd, -nScrollAmt, 0, NULL, NULL ) ;
  632.    XOFFSET( TTYInfo ) = XOFFSET( TTYInfo ) + nScrollAmt ;
  633.    SetScrollPos( hWnd, SB_HORZ, XOFFSET( TTYInfo ), TRUE ) ;
  634.  
  635.    return ( TRUE ) ;
  636.  
  637. } // end of ScrollTTYHorz()
  638.  
  639. //---------------------------------------------------------------------------
  640. //  BOOL NEAR SetTTYFocus( HWND hWnd )
  641. //
  642. //  Description:
  643. //     Sets the focus to the TTY window also creates caret.
  644. //
  645. //  Parameters:
  646. //     HWND hWnd
  647. //        handle to TTY window
  648. //
  649. //---------------------------------------------------------------------------
  650.  
  651. BOOL NEAR SetTTYFocus( HWND hWnd )
  652. {
  653. if (NULL == TTYInfo)
  654.     return ( FALSE ) ;
  655.  
  656.  if (CONNECTED( TTYInfo ) && (CURSORSTATE( TTYInfo ) != CS_SHOW))
  657.  {
  658.       CreateCaret( hWnd, NULL, XCHAR( TTYInfo ), YCHAR( TTYInfo ) ) ;
  659.       ShowCaret( hWnd ) ;
  660.       CURSORSTATE( TTYInfo ) = CS_SHOW ;
  661.  }
  662.    MoveTTYCursor( hWnd ) ;
  663.    return ( TRUE ) ;
  664.  
  665. } // end of SetTTYFocus()
  666.  
  667. //---------------------------------------------------------------------------
  668. //  BOOL NEAR KillTTYFocus( HWND hWnd )
  669. //
  670. //  Description:
  671. //     Kills TTY focus and destroys the caret.
  672. //
  673. //  Parameters:
  674. //     HWND hWnd
  675. //        handle to TTY window
  676. //
  677. //---------------------------------------------------------------------------
  678.  
  679. BOOL NEAR KillTTYFocus( HWND hWnd )
  680. {
  681.    if (NULL == TTYInfo)
  682.       return ( FALSE ) ;
  683.  
  684.    if (CONNECTED( TTYInfo ) && (CURSORSTATE( TTYInfo ) != CS_HIDE))
  685.    {
  686.       HideCaret( hWnd ) ;
  687.       DestroyCaret() ;
  688.       CURSORSTATE( TTYInfo ) = CS_HIDE ;
  689.    }
  690.    return ( TRUE ) ;
  691.  
  692. } // end of KillTTYFocus()
  693.  
  694. //---------------------------------------------------------------------------
  695. //  BOOL NEAR MoveTTYCursor( HWND hWnd )
  696. //
  697. //  Description:
  698. //     Moves caret to current position.
  699. //
  700. //  Parameters:
  701. //     HWND hWnd
  702. //        handle to TTY window
  703. //
  704. //---------------------------------------------------------------------------
  705.  
  706. BOOL NEAR MoveTTYCursor( HWND hWnd )
  707. {
  708.    if (NULL == TTYInfo)
  709.       return ( FALSE ) ;
  710.  
  711.    if (CONNECTED( TTYInfo ) && (CURSORSTATE( TTYInfo ) & CS_SHOW))
  712.       SetCaretPos( (COLUMN( TTYInfo ) * XCHAR( TTYInfo )) -
  713.                    XOFFSET( TTYInfo ),
  714.                    (ROW( TTYInfo ) * YCHAR( TTYInfo )) -
  715.                    YOFFSET( TTYInfo ) ) ;
  716.  
  717.    return ( TRUE ) ;
  718.  
  719. } // end of MoveTTYCursor()
  720.  
  721.  
  722. //---------------------------------------------------------------------------
  723. //  BOOL NEAR ProcessTTYCharacter( HWND hWnd, BYTE bOut )
  724. //
  725. //  Description:
  726. //     This simply writes a character to the port and echos it
  727. //     to the TTY screen if fLocalEcho is set.  Some minor
  728. //     keyboard mapping could be performed here.
  729. //
  730. //  Parameters:
  731. //     HWND hWnd
  732. //        handle to TTY window
  733. //
  734. //     BYTE bOut
  735. //        byte from keyboard
  736. //
  737. //---------------------------------------------------------------------------
  738.  
  739. BOOL NEAR ProcessTTYCharacter( HWND hWnd, BYTE bOut )
  740. {
  741.    if (NULL == TTYInfo)
  742.       return ( FALSE ) ;
  743.  
  744.    if (!CONNECTED( TTYInfo ))
  745.       return ( FALSE ) ;
  746.  
  747.    WriteCommByte( hWnd, bOut ) ;
  748.    if (LOCALECHO( TTYInfo ))
  749.       WriteTTYBlock( hWnd, &bOut, 1 ) ;
  750.  
  751.    return ( TRUE ) ;
  752.  
  753. } // end of ProcessTTYCharacter()
  754.  
  755. //---------------------------------------------------------------------------
  756. //  BOOL NEAR OpenConnection( HWND hWnd )
  757. //
  758. //  Description:
  759. //     Opens communication port specified in the TTYINFO struct.
  760. //     It also sets the CommState and notifies the window via
  761. //     the fConnected flag in the TTYINFO struct.
  762. //
  763. //  Parameters:
  764. //     HWND hWnd
  765. //        handle to TTY window
  766. //
  767. //---------------------------------------------------------------------------
  768.  
  769. void CALLBACK ConnectEvent(
  770.     HPOWERTCP hSession,    /* identifies session notifying our app */ 
  771.     DWORD     UserData,  /* UserData from Connect() function */
  772.     LPCSTR    RemoteDotAddr, /* remote host connected to in dot notation */
  773.     WORD      RemotePort,/* remote port connected to */
  774.     LPCSTR    LocalDotAddr, /* local host address in dot notation */
  775.     WORD      LocalPort, /* local port */
  776.     LPCSTR    LocalName  /* name of default local host */
  777.     )
  778. {
  779. HMENU hMenu;
  780. hMenu = GetMenu( (HWND)LOWORD(UserData) ) ;
  781. EnableMenuItem( hMenu, IDM_DISCONNECT, MF_ENABLED | MF_BYCOMMAND ) ;
  782. EnableMenuItem( hMenu, IDM_CONNECT, MF_GRAYED | MF_DISABLED | MF_BYCOMMAND ) ;  
  783. CONNECTED( TTYInfo ) = TRUE;
  784. SetTTYFocus((HWND)LOWORD(UserData));
  785. }
  786.     
  787. void CALLBACK RecvEvent(
  788.     HPOWERTCP hSession,    /* identifies session notifying our app */ 
  789.     DWORD     UserData,  /* UserData from Open() function */
  790.     LPBYTE    Data,  /* data from remote source */ 
  791.     size_t    Cnt        /* byte count for RecvData */
  792.     )
  793. {
  794.    if (!Data)
  795.        {
  796.         HMENU hMenu;
  797.         KillTTYFocus( (HWND)LOWORD(UserData) ) ;
  798.            CONNECTED( TTYInfo )     = FALSE ;
  799.         
  800.         hPowerTcp=NULL;
  801.         hMenu = GetMenu( (HWND)LOWORD(UserData) ) ;
  802.         EnableMenuItem( hMenu, IDM_CONNECT, MF_ENABLED | MF_BYCOMMAND ) ;
  803.         EnableMenuItem( hMenu, IDM_DISCONNECT, MF_GRAYED | MF_DISABLED | MF_BYCOMMAND ) ;  
  804.         }
  805.     else
  806.         WriteTTYBlock( (HWND) LOWORD(UserData), Data, (int) Cnt );
  807. }    
  808.  
  809. void CALLBACK SendEvent(
  810.     HPOWERTCP hSession,    /* identifies session notifying our app */ 
  811.     DWORD     UserData,  /* UserData from Open() function */
  812.     DWORD     SendInstance /* SendInstance from Send() functions */
  813.     )
  814. {
  815. }
  816.  
  817. void CALLBACK CmdEvent(
  818.     HPOWERTCP hSession,    /* identifies session notifying our app */ 
  819.     DWORD     UserData,  /* UserData from Open() function */
  820.     BYTE      Cmd,       /* TELNET command (WILL, WONT, DO, DONT...) */ 
  821.     BYTE      Option,    /* TELNET option number */ 
  822.     LPBYTE    SubOption, /* pointer to sub-option string */ 
  823.     size_t    SubOptionCnt        /* byte count for SubOption */
  824.     )
  825. {
  826.    switch (Cmd)
  827.        {
  828.        case WILL_CMD:
  829.            if(( Option == 3) || ( Option == 1))
  830.                    SendTelnetCmd(hSession,DO_CMD,Option,NULL,0,0);
  831.            else
  832.                    SendTelnetCmd(hSession,DONT_CMD,Option,NULL,0,0);
  833.            break;
  834.        case WONT_CMD:
  835.            break;
  836.        case DO_CMD:
  837.                if (Option==TERMTYPE_OPTION)
  838.                    // negotiate term type
  839.                    SendTelnetCmd(hSession,WILL_CMD,Option,NULL,0,0);
  840.                else
  841.                    SendTelnetCmd(hSession,WONT_CMD,Option,NULL,0,0);
  842.            break;
  843.        case DONT_CMD:
  844.                SendTelnetCmd(hSession,WONT_CMD,Option,NULL,0,0);
  845.            break;
  846.        case SB_CMD:
  847.            if( SubOptionCnt && SubOption) 
  848.                    SendTelnetCmd(hSession,SB_CMD,Option,(LPBYTE)"\000network",8,0);
  849.            else
  850.                   SendTelnetCmd(hSession,WONT_CMD,Option,NULL,0,0);
  851.            break;
  852.        default:
  853.            break; 
  854.        }           
  855. }    
  856.  
  857. void CALLBACK ExceptionEvent(
  858.     HPOWERTCP hSession,    /* identifies session notifying our app */ 
  859.     DWORD     UserData,  /* UserData from Open() function */
  860.     PT_EXCEPTION ErrorCode,  /* spontaneous error notification */
  861.     LPCSTR    ErrorDesc  /* description of error */
  862.     )          
  863. {
  864. }
  865.                        
  866. //---------------------------------------------------------------------------
  867. //  BOOL FAR PASCAL __export ConnectDlgProc( HWND hDlg, UINT uMsg,
  868. //                                WPARAM wParam, LPARAM lParam )
  869. //
  870. //  Description:
  871. //    Creates a connect box for the connection.
  872. //
  873. //  Parameters:
  874. //     Same as standard dialog procedures.
  875. //
  876. //---------------------------------------------------------------------------
  877. //////////////////////////////////////////////////////////////
  878.  
  879. BOOL CALLBACK ConnectDlgProc( HWND hDlg, UINT uMsg,
  880.                                 WPARAM wParam, LPARAM lParam )
  881. {  
  882.    switch (uMsg)
  883.    {
  884.     case WM_INITDIALOG:
  885.          SetDlgItemText( hDlg, IDC_HOST, szHost ) ;
  886.          SetDlgItemText( hDlg, IDC_PORT, szPort ) ;
  887.     break;
  888.       
  889.     case WM_COMMAND:
  890.       if ((WORD) wParam == IDD_OK)
  891.        {
  892.            GetDlgItemText( hDlg, IDC_HOST, szHost, sizeof( szHost ) ) ;
  893.            Port = (WORD)GetDlgItemInt( hDlg, IDC_PORT, &TransOk, FALSE); 
  894.         EndDialog( hDlg, TRUE ) ;
  895.         return ( TRUE ) ;
  896.        }
  897.        
  898.       if ((WORD) wParam == IDD_CANCEL)
  899.        {
  900.         EndDialog( hDlg, FALSE) ;
  901.         return (FALSE) ;
  902.        }
  903.        
  904.     break;
  905.    }
  906.  return ( FALSE ) ;
  907. } // end of ConnectDlgProc()
  908.  
  909.  
  910.  
  911. BOOL NEAR OpenConnection( HWND hWnd )
  912. {
  913.  
  914. HCURSOR    hOldCursor, hWaitCursor ;
  915.  
  916.    // Prepare callbacks
  917.    MyConnectEvent=MakeProcInstance((FARPROC)ConnectEvent,hInstance);
  918.    MyCmdEvent=MakeProcInstance((FARPROC)CmdEvent,hInstance);
  919.    MyRecvEvent=MakeProcInstance((FARPROC)RecvEvent,hInstance);
  920.    MySendEvent=MakeProcInstance((FARPROC)SendEvent,hInstance);
  921.    MyExceptionEvent=MakeProcInstance((FARPROC)ExceptionEvent,hInstance);
  922.  
  923. // show the hourglass cursor
  924. hWaitCursor = LoadCursor( NULL, IDC_WAIT ) ;
  925. hOldCursor = SetCursor( hWaitCursor ) ;
  926.  
  927.  
  928. if (GoModalDialogBoxParam( hInstance, MAKEINTRESOURCE( CONNECTDLGBOX ), hWnd,
  929.                        ConnectDlgProc, 0l))                        
  930.     hPowerTcp = ConnectTelnet (
  931.     MAKELONG(hWnd,0),        /* user-defined instance passed back by all callback functions */ 
  932.     NULL,                        /* use license number assigned to you by Dart */ 
  933.     PT_SHOW,                    /*  */ 
  934.     (LPCSTR) szHost,           /* use name or dot notation */ 
  935.     Port,                     /* port to connect to (usually 23 for TELNET) */ 
  936.     NULL,                     /* NULL orlocal dot address for multi-homed host */ 
  937.     0, /* use any local port */
  938.     (CONNECTEVENT)ConnectEvent,         /* your event handler for session Open/Close notification */ 
  939.     (RECVEVENT)MyRecvEvent,             /* your event handler for receiving data */ 
  940.     (SENDEVENT)MySendEvent,             /* your event handler for Send confirmation */ 
  941.     (CMDEVENT)MyCmdEvent,               /* your event handler for received TELNET commands */ 
  942.     (EXCEPTIONEVENT)MyExceptionEvent         /* your event handler for exception notifications */
  943.     );
  944.     
  945. if (hPowerTcp)    
  946. return (TRUE);
  947. else 
  948. return (FALSE);                      
  949. } // end of OpenConnection()
  950.  
  951. //---------------------------------------------------------------------------
  952. //  BOOL NEAR CloseConnection( HWND hWnd )
  953. //
  954. //  Description:
  955. //     Closes the connection to the port.  Resets the connect flag
  956. //     in the TTYINFO struct.
  957. //
  958. //  Parameters:
  959. //     HWND hWnd
  960. //        handle to TTY window
  961. //
  962. //---------------------------------------------------------------------------
  963.  
  964. BOOL NEAR CloseConnection( HWND hWnd )
  965. {
  966.     PT_STATE State;
  967.  
  968.     
  969.     if (hPowerTcp)
  970.         State = CloseTelnet(hPowerTcp, FALSE);
  971.    return ( TRUE ) ;
  972.  
  973. } // end of CloseConnection()
  974.  
  975.  
  976. //---------------------------------------------------------------------------
  977. //  BOOL NEAR WriteCommByte( HWND hWnd, BYTE bByte )
  978. //
  979. //  Description:
  980. //     Writes a byte to the COM port specified in the associated
  981. //     TTY info structure.
  982. //
  983. //  Parameters:
  984. //     HWND hWnd
  985. //        handle to TTY window
  986. //
  987. //     BYTE bByte
  988. //        byte to write to port
  989. //
  990. //---------------------------------------------------------------------------
  991.  
  992. BOOL NEAR WriteCommByte( HWND hWnd, BYTE bByte )
  993. {
  994.    if (NULL == TTYInfo)
  995.       return ( FALSE ) ;
  996.  
  997.    //WriteComm( COMDEV( TTYInfo ), (LPSTR) &bByte, 1 ) ;
  998.    SendTelnet(hPowerTcp, &bByte, 1, FALSE, 0);
  999.  
  1000.    return ( TRUE ) ;
  1001.  
  1002. } // end of WriteCommByte()
  1003.  
  1004. //---------------------------------------------------------------------------
  1005. //  BOOL NEAR WriteTTYBlock( HWND hWnd, LPSTR lpBlock, int nLength )
  1006. //
  1007. //  Description:
  1008. //     Writes block to TTY screen.  Nothing fancy - just
  1009. //     straight TTY.
  1010. //
  1011. //  Parameters:
  1012. //     HWND hWnd
  1013. //        handle to TTY window
  1014. //
  1015. //     LPSTR lpBlock
  1016. //        far pointer to block of data
  1017. //
  1018. //     int nLength
  1019. //        length of block
  1020. //
  1021. //---------------------------------------------------------------------------
  1022.  
  1023. BOOL NEAR WriteTTYBlock( HWND hWnd, LPBYTE lpBlock, int nLength )
  1024. {
  1025.    int        i ;
  1026.    RECT       rect ;
  1027.  
  1028.    if (NULL == TTYInfo)
  1029.       return ( FALSE ) ;
  1030.  
  1031.    for (i = 0 ; i < nLength; i++)
  1032.    {
  1033.       switch (lpBlock[ i ])
  1034.       {
  1035.            case 0:
  1036.              // do not print NULLs
  1037.             break;
  1038.  
  1039.          case ASCII_BEL:
  1040.             // Bell
  1041.             MessageBeep( 0 ) ;
  1042.             break ;
  1043.  
  1044.          case ASCII_BS:
  1045.             // Backspace
  1046.             if (COLUMN( TTYInfo ) > 0)
  1047.                COLUMN( TTYInfo ) -- ;
  1048.             MoveTTYCursor( hWnd ) ;
  1049.             break ;
  1050.  
  1051.          case ASCII_CR:
  1052.             // Carriage return
  1053.             COLUMN( TTYInfo ) = 0 ;
  1054.             MoveTTYCursor( hWnd ) ;
  1055.             if (!NEWLINE( TTYInfo ))
  1056.                break;
  1057.  
  1058.             // fall through
  1059.  
  1060.          case ASCII_LF:
  1061.             // Line feed
  1062.             if (ROW( TTYInfo )++ == MAXROWS - 1)
  1063.             {
  1064.                memmove( (SCREEN( TTYInfo )),
  1065.                           (SCREEN( TTYInfo ) + MAXCOLS),
  1066.                           (MAXROWS - 1) * MAXCOLS ) ;
  1067.                memset( (SCREEN( TTYInfo ) + (MAXROWS - 1) * MAXCOLS),
  1068.                          ' ', MAXCOLS ) ;
  1069.                InvalidateRect( hWnd, NULL, FALSE ) ;
  1070.                ROW( TTYInfo )-- ;
  1071.             }
  1072.             MoveTTYCursor( hWnd ) ;
  1073.             break ;
  1074.  
  1075.          default:
  1076.             *(SCREEN( TTYInfo ) + ROW( TTYInfo ) * MAXCOLS +
  1077.                 COLUMN( TTYInfo )) = lpBlock[ i ] ;
  1078.             rect.left = (COLUMN( TTYInfo ) * XCHAR( TTYInfo )) -
  1079.                         XOFFSET( TTYInfo ) ;
  1080.             rect.right = rect.left + XCHAR( TTYInfo ) ;
  1081.             rect.top = (ROW( TTYInfo ) * YCHAR( TTYInfo )) -
  1082.                        YOFFSET( TTYInfo ) ;
  1083.             rect.bottom = rect.top + YCHAR( TTYInfo ) ;
  1084.             InvalidateRect( hWnd, &rect, FALSE ) ;
  1085.  
  1086.             // Line wrap
  1087.             if (COLUMN( TTYInfo ) < MAXCOLS - 1)
  1088.                COLUMN( TTYInfo )++ ;
  1089.             else if (AUTOWRAP( TTYInfo ))
  1090.                WriteTTYBlock( hWnd, (LPBYTE)"\r\n", 2 ) ;
  1091.             break;
  1092.       }
  1093.    }
  1094.    return ( TRUE ) ;
  1095.  
  1096. } // end of WriteTTYBlock()
  1097. //---------------------------------------------------------------------------
  1098. //  HWND NEAR InitInstance( HANDLE hInstance, int nCmdShow )
  1099. //
  1100. //  Description:
  1101. //     Initializes instance specific information.
  1102. //
  1103. //  Parameters:
  1104. //     HANDLE hInstance
  1105. //        Handle to instance
  1106. //
  1107. //     int nCmdShow
  1108. //        How do we show the window?
  1109. //
  1110. //---------------------------------------------------------------------------
  1111.  
  1112.  
  1113. HWND NEAR InitInstance( HINSTANCE hInstance, int nCmdShow )
  1114. {
  1115.    HWND  hTTYWnd ;
  1116.    
  1117.    // load accelerators
  1118.    ghAccel = LoadAccelerators( hInstance, MAKEINTRESOURCE( TTYACCEL ) ) ;
  1119.  
  1120.    // create the TTY window
  1121.    hTTYWnd = CreateWindow( gszTTYClass, gszAppName,
  1122.                            WS_OVERLAPPEDWINDOW,
  1123.                            CW_USEDEFAULT, CW_USEDEFAULT,
  1124.                            CW_USEDEFAULT, CW_USEDEFAULT,
  1125.                            NULL, NULL, hInstance, NULL ) ;
  1126.  
  1127.    if (NULL == hTTYWnd)
  1128.       return ( NULL ) ;
  1129.  
  1130.    ShowWindow( hTTYWnd, nCmdShow ) ;
  1131.    UpdateWindow( hTTYWnd ) ;
  1132.    SetWindowText(hTTYWnd, " PowerTCP TELNET Demo ");
  1133.    OpenConnection(hTTYWnd);
  1134.  
  1135.    return ( hTTYWnd ) ;
  1136.  
  1137. } // end of InitInstance()
  1138.  
  1139.  
  1140. //---------------------------------------------------------------------------
  1141. //  VOID NEAR GoModalDialogBoxParam( HINSTANCE hInstance,
  1142. //                                   LPCSTR lpszTemplate, HWND hWnd,
  1143. //                                   DLGPROC lpDlgProc, LPARAM lParam )
  1144. //
  1145. //  Description:
  1146. //     It is a simple utility function that simply performs the
  1147. //     MPI and invokes the dialog box with a DWORD paramter.
  1148. //
  1149. //  Parameters:
  1150. //     similar to that of DialogBoxParam() with the exception
  1151. //     that the lpDlgProc is not a procedure instance
  1152. //
  1153. //---------------------------------------------------------------------------
  1154.  
  1155. BOOL  NEAR GoModalDialogBoxParam( HINSTANCE hInstance, LPCSTR lpszTemplate,
  1156.                              HWND hWnd, DLGPROC lpDlgProc, LPARAM lParam )
  1157. {
  1158.     //FARPROC Proc=MakeProcInstance((FARPROC)lpDlgProc,hInstance);   
  1159.     BOOL DlgResp  = DialogBoxParam( hInstance, lpszTemplate, hWnd, (DLGPROC)lpDlgProc, lParam ) ;
  1160.     //FreeProcInstance(Proc);
  1161.    return (DlgResp);
  1162. } // end of GoModalDialogBoxParam()
  1163.  
  1164. //---------------------------------------------------------------------------
  1165. //  BOOL FAR PASCAL __export AboutDlgProc( HWND hDlg, UINT uMsg,
  1166. //                                WPARAM wParam, LPARAM lParam )
  1167. //
  1168. //  Description:
  1169. //     Simulates the Windows System Dialog Box.
  1170. //
  1171. //  Parameters:
  1172. //     Same as standard dialog procedures.
  1173. //
  1174. //---------------------------------------------------------------------------
  1175.  
  1176. BOOL CALLBACK AboutDlgProc( HWND hDlg, UINT uMsg,
  1177.                               WPARAM wParam, LPARAM lParam )
  1178. {
  1179.    switch (uMsg)
  1180.    {
  1181.       case WM_INITDIALOG:
  1182.       {
  1183.          char         szBuffer[ MAXLEN_TEMPSTR ], szTemp[ MAXLEN_TEMPSTR ] ;
  1184.          DWORD        dwFreeMemory;
  1185.          WORD         wRevision, wVersion ;
  1186.  
  1187. #ifdef ABOUTDLG_USEBITMAP
  1188.          // if we are using the bitmap, hide the icon
  1189.  
  1190.          ShowWindow( GetDlgItem( hDlg, IDD_ABOUTICON ), SW_HIDE ) ;
  1191. #endif
  1192.          // sets up the version number for Windows
  1193.  
  1194.          wVersion = LOWORD( GetVersion() ) ;
  1195.          switch (HIBYTE( wVersion ))
  1196.          {
  1197.             case 10:
  1198.                wRevision = 1 ;
  1199.                break ;
  1200.  
  1201.             default:
  1202.                wRevision = 0 ;
  1203.                break;
  1204.          }
  1205.          wVersion &= 0xFF ;
  1206.  
  1207.          GetDlgItemText( hDlg, IDD_TITLELINE, szTemp, sizeof( szTemp ) ) ;
  1208.          wsprintf( szBuffer, szTemp, wVersion, wRevision ) ;
  1209.          SetDlgItemText( hDlg, IDD_TITLELINE, szBuffer ) ;
  1210.  
  1211.          // sets up version number for TTY
  1212.  
  1213.          GetDlgItemText( hDlg, IDD_VERSION, szTemp, sizeof( szTemp ) ) ;
  1214.          wsprintf( szBuffer, szTemp, VER_MAJOR, VER_MINOR, VER_BUILD ) ;
  1215.          SetDlgItemText( hDlg, IDD_VERSION, (LPSTR) szBuffer ) ;
  1216.  
  1217.          // get free memory information
  1218.  
  1219.          dwFreeMemory = GetFreeSpace( 0 ) / 1024L ;
  1220.          GetDlgItemText( hDlg, IDD_FREEMEM, szTemp, sizeof( szTemp ) ) ;
  1221.          wsprintf( szBuffer, szTemp, dwFreeMemory ) ;
  1222.          SetDlgItemText( hDlg, IDD_FREEMEM, (LPSTR) szBuffer ) ;
  1223.  
  1224.       }
  1225.       return ( TRUE ) ;
  1226.  
  1227. #ifdef ABOUTDLG_USEBITMAP
  1228.       // used to paint the bitmap
  1229.  
  1230.       case WM_PAINT:
  1231.       {
  1232.          HBITMAP      hBitMap ;
  1233.          HDC          hDC, hMemDC ;
  1234.          PAINTSTRUCT  ps ;
  1235.  
  1236.          // load bitmap and display it
  1237.  
  1238.          hDC = BeginPaint( hDlg, &ps ) ;
  1239.          if (NULL != (hMemDC = CreateCompatibleDC( hDC )))
  1240.          {
  1241.             hBitMap = LoadBitmap( hInstance,
  1242.                                   MAKEINTRESOURCE( TTYBITMAP ) ) ;
  1243.             hBitMap = (HBITMAP)SelectObject( hMemDC, hBitMap ) ;
  1244.             BitBlt( hDC, 10, 10, 64, 64, hMemDC, 0, 0, SRCCOPY ) ;
  1245.             DeleteObject( SelectObject( hMemDC, hBitMap ) ) ;
  1246.             DeleteDC( hMemDC ) ;
  1247.          }
  1248.          EndPaint( hDlg, &ps ) ;
  1249.       }
  1250.       break ;
  1251. #endif
  1252.  
  1253.       case WM_COMMAND:
  1254.          if ((WORD) wParam == IDD_OK)
  1255.          {
  1256.             EndDialog( hDlg, TRUE ) ;
  1257.             return ( TRUE ) ;
  1258.          }
  1259.          break;
  1260.    }
  1261.    return ( FALSE ) ;
  1262.  
  1263. } // end of AboutDlgProc()
  1264.  
  1265.  
  1266.